use async_trait::async_trait;
use fluviox_shared::{Result, models::DataRecord};
use serde_json::Value;
use std::collections::HashMap;

/// SmartModule处理结果
#[derive(Debug, Clone)]
pub enum ProcessResult {
    /// 保持记录不变
    Keep(DataRecord),
    /// 转换记录
    Transform(DataRecord),
    /// 过滤掉记录
    Filter,
    /// 分割为多个记录
    Split(Vec<DataRecord>),
    /// 聚合记录（延迟输出）
    Aggregate,
}

/// SmartModule trait - 所有智能模块的基础接口
#[async_trait]
pub trait SmartModule: Send + Sync {
    /// 模块名称
    fn name(&self) -> &str;
    
    /// 模块版本
    fn version(&self) -> &str;
    
    /// 模块描述
    fn description(&self) -> &str;
    
    /// 模块类型
    fn module_type(&self) -> SmartModuleType;
    
    /// 初始化模块
    async fn initialize(&mut self, config: Value) -> Result<()>;
    
    /// 处理单个记录
    async fn process(&mut self, record: DataRecord) -> Result<Vec<ProcessResult>>;
    
    /// 批量处理记录
    async fn process_batch(&mut self, records: Vec<DataRecord>) -> Result<Vec<DataRecord>> {
        let mut results = Vec::new();
        
        for record in records {
            let process_results = self.process(record).await?;
            for result in process_results {
                match result {
                    ProcessResult::Keep(r) | ProcessResult::Transform(r) => {
                        results.push(r);
                    },
                    ProcessResult::Split(mut rs) => {
                        results.append(&mut rs);
                    },
                    ProcessResult::Filter | ProcessResult::Aggregate => {
                        // 过滤掉或聚合（暂不输出）
                    },
                }
            }
        }
        
        Ok(results)
    }
    
    /// 完成处理（用于聚合模块输出最终结果）
    async fn finalize(&mut self) -> Result<Vec<DataRecord>> {
        Ok(vec![])
    }
    
    /// 重置模块状态
    async fn reset(&mut self) -> Result<()> {
        Ok(())
    }
}

/// SmartModule类型
#[derive(Debug, Clone, PartialEq)]
pub enum SmartModuleType {
    /// 过滤器
    Filter,
    /// 转换器
    Transform,
    /// 聚合器
    Aggregator,
    /// 分割器
    Splitter,
    /// 路由器
    Router,
}

/// 过滤器trait
#[async_trait]
pub trait Filter: SmartModule {
    /// 判断记录是否应该被保留
    async fn should_keep(&self, record: &DataRecord) -> Result<bool>;
}

/// 转换器trait
#[async_trait]
pub trait Transform: SmartModule {
    /// 转换记录
    async fn transform(&self, record: DataRecord) -> Result<DataRecord>;
}

/// 聚合器trait
#[async_trait]
pub trait Aggregator: SmartModule {
    /// 聚合记录
    async fn aggregate(&mut self, record: DataRecord) -> Result<()>;
    
    /// 获取聚合结果
    async fn get_result(&self) -> Result<Option<DataRecord>>;
    
    /// 清空聚合状态
    async fn clear(&mut self) -> Result<()>;
}

/// SmartModule配置
#[derive(Debug, Clone)]
pub struct SmartModuleConfig {
    /// 模块名称
    pub name: String,
    /// 模块类型
    pub module_type: SmartModuleType,
    /// 配置参数
    pub parameters: HashMap<String, Value>,
    /// 是否启用
    pub enabled: bool,
    /// 执行顺序
    pub order: u32,
}

/// SmartModule元数据
#[derive(Debug, Clone)]
pub struct SmartModuleMetadata {
    /// 模块名称
    pub name: String,
    /// 版本
    pub version: String,
    /// 描述
    pub description: String,
    /// 类型
    pub module_type: SmartModuleType,
    /// 配置模式
    pub config_schema: Value,
    /// 示例配置
    pub example_config: Value,
}

/// SmartModule工厂trait
pub trait SmartModuleFactory: Send + Sync {
    /// 创建SmartModule实例
    fn create(&self, config: SmartModuleConfig) -> Result<Box<dyn SmartModule>>;
    
    /// 获取支持的模块列表
    fn supported_modules(&self) -> Vec<SmartModuleMetadata>;
    
    /// 验证配置
    fn validate_config(&self, module_type: &str, config: &Value) -> Result<()>;
}
